package com.atguigu.demo;


import java.util.Arrays;
import java.util.Comparator;

/**
 * lamda 表达式：：是函数式编程中的概念
 *          Java在jdk8引入了函数式编程
 *     作用：使用函数式编程的方式创建一个 函数式接口的实例
 *          只能为标注了@FunctionalInterface的接口提供实例
 *                  标注了@FunctionalInterface的接口，除了继承Object的抽象方法外，只有一个自己拥有的抽象方法！
 *     函数式编程的方式格式：
 *              () -> {}
 *                  ():接口中必须实现的抽象方法的参数列表
 *                      参数类型：可以省略，由编译器去推导
 *                      参数列表中只有一个参数，（）也可以省略
 *
 *                  {}：接口中必须实现的抽象方法的方法体
 *                      如果只有一行代码，{}可以省略。return也可以省略
 */
//public class LamdaDemo {
//    public static void main(String[] args) {
//        //传统的面向对象编程方式，创建一个Comparator接口的实例
//        //使用匿名内部类的方式
//        Comparator<Integer> c1 = new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return o1.compareTo(o2);
//            }
//
//        };
//
//
//        System.out.println(c1.getClass().getInterfaces());
//
//        //使用lamda表达式实现
//        Comparator<Integer> c2 = ( o1 , o2) -> o1.compareTo(o2);
//
//        System.out.println(Arrays.toString(c2.getClass().getInterfaces()));
//
//        /*
//        lamda表达式的特殊方式 方法引用
//        （） -> {} 中方法的实现和一个现成的方法的实现一摸一样
//                本着站在巨人的肩膀上，不断重复造轮子的原则，可以直接把别人已经写好的方法拿来当作自己接口方法的实现
//
//                简称：方法引用。 不自己写，引用别人写好的方法
//                格式：类名::方法名
//         */
//
//        Comparator<Integer> c3 = ( Integer x,Integer y) ->{
//            return (x < y) ? -1 : ((x == y) ? 0 : 1);
//        };
//    }
//}

//public class LamdaDemo {
//    public static void main(String[] args) {
//        //传统的面向对象编程方式，创建一个Comparator接口的实例
//        //使用匿名内部类的方式
//        Comparator<Integer> c1 = new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return o1.compareTo(o2);
//            }
//        };
//        System.out.println(Arrays.toString(c1.getClass().getInterfaces()));
//
//
//        //使用lamda表达式去实现
//        Comparator<Integer> c2 = ( o1,o2) -> o1.compareTo(o2);
//
//        System.out.println(Arrays.toString(c2.getClass().getInterfaces()));
//
//        /*
//        lamda表达式的特殊方式 方法引用
//
//        () -> {} 中方法的实现和一个现成的方法的实现一摸一样
//            本着站在巨人的肩膀上，不要重复造轮子的原则，可以直接把别人已经写好的方法拿过来当作自己接口方法的实现。
//            简称：方法引用。 不自己写，引用别人写好的方法
//            格式： 类名::方法名
//         */
//        Comparator<Integer> c3 = (Integer x,Integer y) -> {
//            return (x < y ) ? -1 : (( x == y ) ? 0 : 1);
//        };
//
//        Comparator<Integer> c4 = Integer::compareTo;
//    }
//}

public class LamdaDemo {
    public static void main(String[] args) {
        //传统的面向对象的编程方式，创建一个Comparator接口的实例
        //使用匿名内部类的方式
        Comparator<Integer> c1 = new Comparator<Integer>() {

            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };

        System.out.println(Arrays.toString(c1.getClass().getInterfaces()));


        //使用lamda表达式实现
        Comparator<Integer> c2 = ( o1,o2 ) -> o1.compareTo(o2);

        System.out.println(Arrays.toString(c2.getClass().getInterfaces()));

        /*
        lamda表达式的特殊方式 方法引用

        () -> {} 中方法的实现和一个现成的方法的实现一摸一样
        本着站在巨人的肩膀上，不要重复造轮子的原则，可以直接把别人已经写好的方法拿过来当作自己接口方法的实现。
        简称：方法引用。不自己写，引用别人先写好的方法
        格式： 类名::方法名
         */
        Comparator<Integer> c3 = (Integer x,Integer y) -> {
            return (x < y) ? -1 : ((x == y) ? 0 : 1);
        };

        Comparator<Integer> c4 = Integer::compareTo;
    }
}